Puhaste koodiprintsiibid: Hooldatavate Pythoni rakenduste loomine

Tarkvaraarenduse maailmas ei saa üle tähtsustada puhta ja hooldatava koodi kirjutamise olulisust. Kuigi programm võib algselt korrektselt töötada, võivad halvasti kirjutatud koodi pikaajalised kulud olla märkimisväärsed. See kehtib eriti Pythoni kohta, keele kohta, mis on tuntud oma loetavuse ja mitmekülgsuse poolest. Järgides puhta koodi põhimõtteid, saate luua Pythoni rakendusi, mida on lihtsam mõista, muuta ja mille kallal koos töötada, säästes lõppkokkuvõttes aega ja ressursse.

Miks puhas kood oluline on

Puhas kood ei ole ainult esteetika küsimus; see on kestva tarkvara loomine. Siin on põhjus, miks see on ülioluline:

• Parem loetavus: Kood peaks olema lihtsasti loetav ja mõistetav, isegi arendajatele, kes pole koodibaasiga kursis. See vähendab aega, mis kulub loogika mõistmiseks ja muudatuste tegemiseks.
• Vähenenud silumisaeg: Puhast koodi on lihtsam siluda, sest loogika on selge ja võimalikud veaalikad on kergemini tuvastatavad.
• Täiustatud hooldatavus: Hästi struktureeritud koodi on aja jooksul lihtsam hooldada ja muuta, võimaldades kiiremaid uuendusi ja veaparandusi.
• Suurenenud koostöö: Puhas kood hõlbustab arendajate vahelist koostööd, kuna hästi organiseeritud koodibaasi on lihtsam mõista ja sinna panustada.
• Vähenenud tehniline võlg: Puhas kood minimeerib tehnilist võlga, mis on ümbertöötluse kaudne kulu, mis on põhjustatud praegu lihtsa lahenduse valimisest parema lähenemise asemel, mis võtaks kauem aega.
• Parem testitavus: Puhast koodi on lihtsam testida, mis võimaldab kirjutada tõhusaid ühik- ja integratsiooniteste, mis tagavad teie tarkvara kvaliteedi.

Puhta koodi põhiprintsiibid Pythonis

Pythonis puhta koodi loomist juhivad mitmed põhimõtted. Need põhimõtted ei ole jäigad reeglid, vaid pigem juhised, mis aitavad teil kirjutada hooldatavamat ja loetavamat koodi.

1. Järgige PEP 8 – Pythoni koodi stiilijuhist

PEP 8 on Pythoni koodi ametlik stiilijuhis. PEP 8 järgimine tagab teie koodibaasi ühtsuse ja loetavuse. Tööriistad nagu flake8 ja pylint saavad automaatselt kontrollida teie koodi vastavust PEP 8-le. PEP 8 ignoreerimine võib põhjustada vastuolusid ja muuta teie koodi teistele Pythoni arendajatele raskemini loetavaks. PEP 8 näidisjuhised hõlmavad:

• Taandamine: Kasutage taandamiseks 4 tühikut.
• Rea pikkus: Piirake read 79 märgiga.
• Tühjad read: Kasutage tühje ridu funktsioonide, klasside ja loogiliste koodiplokkide eraldamiseks.
• Nimetamise tavad: Kasutage muutujate, funktsioonide ja klasside jaoks kirjeldavaid ja järjepidevaid nimetamiskonventsioone (nt snake_case muutujate ja funktsioonide puhul, CamelCase klasside puhul).
• Kommentaarid: Kirjutage selged ja lühikesed kommentaarid keerulise loogika või mittelihtsa koodi selgitamiseks.

Näide:

Ei vasta PEP 8-le:

            def calculate_area(length,width):
 area=length*width
 return area
            

              
                Copy
              
            
          

Vastab PEP 8-le:

            def calculate_area(length, width):
  """Arvutab ristküliku pindala."""
  area = length * width
  return area

            

              
                Copy
              
            
          

2. Tähenduslikud nimed

Kirjeldavate ja tähenduslike nimede valimine muutujate, funktsioonide ja klasside jaoks on koodi loetavuse seisukohalt ülioluline. Nimed peaksid selgelt näitama nendevahelise üksuse eesmärki.

• Olge kirjeldav: Valige nimed, mis kirjeldavad täpselt üksuse eesmärki või funktsionaalsust.
• Olge järjepidev: Kasutage kogu koodibaasis järjepidevaid nimetamiskonventsioone.
• Vältige lühendeid: Minimeerige lühendite kasutamist, eriti ebaselgete lühendite puhul. Kuigi mõned levinud lühendid on vastuvõetavad (nt i indeksi jaoks tsüklis), vältige liigselt lühendatud nimesid, mida võib olla raske mõista.
• Kasutage hääldatavaid nimesid: Nimed peaksid olema kergesti hääldatavad, muutes need lihtsamini arutatavaks ja meeldejäetavaks.

Näide:

Halb nimetamine:

            def calc(x, y):
  return x * y

            

              
                Copy
              
            
          

Hea nimetamine:

            def calculate_total_price(quantity, unit_price):
  """Arvutab koguhinna koguse ja ühikuhinna alusel."""
  return quantity * unit_price

            

              
                Copy
              
            
          

3. Funktsioonid peaksid tegema ühte asja

Funktsioonil peaks olema üks, hästi määratletud eesmärk. Kui funktsioon täidab mitu ülesannet, muutub seda raskemaks mõista, testida ja hooldada. Jagage keerulised funktsioonid väiksemateks, fokusseeritumataks funktsioonideks.

• Hoidke funktsioonid väikesed: Püüdke kirjutada lühikesi ja kompaktseid funktsioone, tavaliselt mitte rohkem kui paar rida koodi.
• Vältige kõrvalmõjusid: Funktsioon peaks ideaalis muutma ainult oma kohalikke muutujaid ja tagastama väärtuse. Vältige funktsioone, millel on soovimatud kõrvalmõjud, näiteks globaalsete muutujate muutmine või I/O toimingute teostamine.
• Kasutage kirjeldavaid nimesid: Hästi valitud funktsiooni nimi aitab edastada selle ühtset eesmärki.

Näide:

Funktsioon, mis teeb mitut asja:

            def process_order(order):
  """Töötleb tellimust, sh valideerimine, arvutamine ja andmebaasi uuendamine."""
  if not order.is_valid():
   print("Vigane tellimus")
   return
  total = order.calculate_total()
  order.update_database(total)

            

              
                Copy
              
            
          

Refaktoritud väiksemateks funktsioonideks:

            def is_order_valid(order):
  """Valideerib tellimuse."""
  # Valideerimisloogika
  return order.is_valid()

def calculate_order_total(order):
  """Arvutab tellimuse kogusumma."""
  return order.calculate_total()

def update_order_database(order, total):
  """Uuendab tellimuse andmebaasi kogusummaga."""
  order.update_database(total)

def process_order(order):
  """Töötleb tellimust valideerides, kogusumma arvutades ja andmebaasi uuendades."""
  if not is_order_valid(order):
   print("Vigane tellimus")
   return
  total = calculate_order_total(order)
  update_order_database(order, total)

            

              
                Copy
              
            
          

4. Vältige dubleerimist (DRY – Ära korda ennast)

Koodi dubleerimine on levinud vigade allikas ja muudab koodi hooldamise raskemaks. Kui leiate end sama koodi mitmes kohas kordamast, kaaluge selle eraldamist korduvkasutatavaks funktsiooniks või klassiks.

• Eraldage ühine loogika: Tuvastage ja eraldage ühine loogika funktsioonideks või klassideks, mida saab kogu koodibaasis taaskasutada.
• Kasutage tsükleid ja iteraatoreid: Kasutage tsükleid ja iteraatoreid, et vältida sarnase koodi kordamist erinevate andmeelementide puhul.
• Kaaluge malli disainimustrit: Keerulisemate stsenaariumide puhul kaaluge disainimustrite, nagu mallmeetod, kasutamist dubleerimise vältimiseks.

Näide:

Dubleeritud kood:

            def calculate_square_area(side):
  return side * side

def calculate_cube_volume(side):
  return side * side * side

            

              
                Copy
              
            
          

DRY kood:

            def calculate_power(base, exponent):
  return base ** exponent

def calculate_square_area(side):
  return calculate_power(side, 2)

def calculate_cube_volume(side):
  return calculate_power(side, 3)

            

              
                Copy
              
            
          

5. Kirjutage häid kommentaare

Kommentaarid peaksid selgitama miks, mitte mida. Kood peaks olema iseenesestmõistetav, kuid kommentaarid võivad anda väärtuslikku konteksti ja selgitusi teatud otsuste põhjenduste kohta. Vältige üleliigseid kommentaare, mis lihtsalt kordavad seda, mida kood juba teeb.

• Selgitage eesmärki: Kommentaarid peaksid selgitama koodi eesmärki, eriti kui see pole koheselt ilmne.
• Dokumenteerige eeldused: Dokumenteerige kõik eeldused või piirangud, millele kood toetub.
• Selgitage keerulist loogikat: Kasutage kommentaare keeruliste algoritmide või mittelihtsa koodi selgitamiseks.
• Hoidke kommentaarid ajakohased: Veenduge, et kommentaare uuendatakse alati, kui koodi muudetakse. Aegunud kommentaarid võivad olla kahjulikumad kui üldse mitte kommentaare.
• Kasutage Docstringe: Kasutage dokstringe ("""...""") moodulite, klasside ja funktsioonide dokumenteerimiseks. Dokstringe kasutavad dokumentatsiooni generaatorid ja IDE-d, et anda abi ja teavet teie koodi kohta.

Näide:

Halb kommentaar:

            x = x + 1  # Suurenda x

            

              
                Copy
              
            
          

Hea kommentaar:

            x = x + 1  # Suurenda x, et liikuda loendis järgmise üksuse juurde

            

              
                Copy
              
            
          

6. Käsitle vead viisakalt

Robustne kood ennetab võimalikke vigu ja käsitleb neid graatsiliselt. Kasutage try-except plokke erandite püüdmiseks ja programmi kokkujooksmise vältimiseks. Esitage informatiivseid veateateid, et aidata kasutajatel probleeme diagnoosida ja lahendada.

• Kasutage try-except plokke: Mässige potentsiaalselt veaohtlik kood try-except plokkidesse erandite püüdmiseks.
• Käsitlege konkreetseid erandeid: Püüdke kinni konkreetsed erandid, selle asemel et kasutada üldist except plokki. See võimaldab teil käsitleda erinevat tüüpi vigu erinevatel viisidel.
• Esitage informatiivsed veateated: Lisage informatiivsed veateated, mis aitavad kasutajatel mõista vea põhjust ja kuidas seda parandada.
• Logi vead: Logige vead faili või andmebaasi hilisemaks analüüsiks. See aitab teil tuvastada ja parandada korduvaid probleeme.

Näide:

            def divide(x, y):
  try:
   result = x / y
   return result
  except ZeroDivisionError:
   print("Viga: Nulliga jagamine pole lubatud.")
   return None

            

              
                Copy
              
            
          

7. Kirjutage ühikteste

Ühikutestid on väikesed automatiseeritud testid, mis kontrollivad koodi üksikute ühikute, näiteks funktsioonide või klasside funktsionaalsust. Ühikutestide kirjutamine on puhta koodi arenduse oluline osa. Ühikutestid aitavad teil:

• Tuvasta vead varakult: Ühikutestid võivad tuvastada vead arendustsükli alguses, enne kui need tootmisse jõuavad.
• Tagada koodi kvaliteet: Ühikutestid pakuvad turvavõrku, mis võimaldab teil oma koodi kindlalt refaktorida, teades, et saate hõlpsasti kontrollida, et teie muudatused pole regressioone tekitanud.
• Dokumenteerige kood: Ühikutestid võivad toimida teie koodi dokumentatsioonina, illustreerides, kuidas seda on ette nähtud kasutada.

Pythonil on mitmeid populaarseid testimisraamistikke, sealhulgas unittest ja pytest. Testipõhise arenduse (TDD) kasutamine, kus kirjutate testid enne koodi kirjutamist, võib oluliselt parandada koodi disaini. Kaaluge "mocking" teekide (nagu unittest.mock) kasutamist testitavate ühikute isoleerimiseks.

Näide (kasutades unittest-i):

            import unittest

def add(x, y):
  return x + y

class TestAdd(unittest.TestCase):
  def test_add_positive_numbers(self):
   self.assertEqual(add(2, 3), 5)
  def test_add_negative_numbers(self):
   self.assertEqual(add(-2, -3), -5)
  def test_add_mixed_numbers(self):
   self.assertEqual(add(2, -3), -1)

if __name__ == '__main__':
  unittest.main()

            

              
                Copy
              
            
          

8. Hoidke see lihtsana (KISS – Keep It Simple, Stupid)

Lihtsus on tarkvaraarenduses voorus. Püüdke kirjutada koodi, mis on võimalikult lihtne ja otsekohene. Vältige üleinsenerlust või tarbetu keerukuse lisamist. Sageli on lihtsaim lahendus parim lahendus.

• Vältige üleinsenerlust: Ärge lisage funktsioone ega keerukust, mida praegu vaja ei ole.
• Kasutage lihtsaid andmestruktuure: Valige lihtsaim andmestruktuur, mis vastab teie nõuetele.
• Kirjutage selge ja lühike kood: Kasutage selget ja lühikest keelt ning vältige tarbetut koodi.

9. Sa seda ei vaja (YAGNI)

See põhimõte on tihedalt seotud KISS-iga. YAGNI ütleb, et te ei tohiks funktsionaalsust lisada enne, kui seda tegelikult vaja on. Vältige funktsioonide või keerukuse lisamist tulevaste nõuete spekulatsioonide alusel. See aitab vältida üleinsenerlust ja hoiab teie koodi keskendununa praegustele vajadustele.

10. Eelistage kompositsiooni pärandusele

Kuigi pärandamine võib olla kasulik tööriist, võib see viia ka keerulise ja habras koodini, eriti kui seda liigselt kasutada. Kompositsioon seevastu hõlmab objektide loomist, kombineerides väiksemaid, spetsialiseeritumaid objekte. Kompositsioon pakub suuremat paindlikkust ja vähendab klasside tihedalt sidumise riski.

Näide: Selle asemel, et luua Dog klass, mis pärib Animal klassist ja rakendab ka Barkable liidest, võite luua Dog klassi, millel on Animal objekt ja BarkingBehavior objekt.

Refaktorimine: olemasoleva koodi parendamine

Refaktorimine on olemasoleva koodi sisemise struktuuri parandamise protsess, muutmata selle välist käitumist. Refaktorimine on puhta koodi arendamise oluline osa. See võimaldab teil aja jooksul oma koodi kvaliteeti järk-järgult parandada.

Levinud refaktorimistehnikad:

• Eralda funktsioon: Eraldage koodiplokk uude funktsiooni.
• Nimeta muutuja/funktsioon/klass ümber: Nimetage muutuja, funktsioon või klass ümber, et selle eesmärk oleks selgem.
• Tutvusta parameetriobjekt: Asendage mitu parameetrit ühe parameetriobjektiga.
• Asenda tingimuslik polümorfismiga: Asendage keeruline tingimuslause polümorfismiga.

Tööriistad puhta koodi jaoks

Mitmed tööriistad aitavad teil Pythonis puhtamat koodi kirjutada:

• flake8: Linter, mis kontrollib teie koodi vastavust PEP 8-le ja muudele stiiliprobleemidele.
• pylint: Põhjalikum linter, mis analüüsib teie koodi võimalike vigade, stiiliprobleemide ja koodilõhnade osas.
• black: Põhjalik koodivormindaja, mis vormindab teie koodi automaatselt järjepideva stiili järgi.
• mypy: Staatiline tüübikontrollija, mis aitab teil tüüpvigadest varakult arendustsükli jooksul kinni püüda.

Kokkuvõte

Puhta koodi kirjutamine on investeering teie tarkvara pikaajalisse tervisesse. Järgides puhta koodi põhimõtteid, saate luua Pythoni rakendusi, mida on lihtsam mõista, hooldada ja mille kallal koos töötada. See viib lõppkokkuvõttes suurema tootlikkuseni, madalamate kuludeni ja kvaliteetsema tarkvarani. Võtke need põhimõtted ja tööriistad omaks ning olete teel tõhusama ja professionaalsema Pythoni arendaja poole. Pidage meeles, et puhas kood ei ole lihtsalt tore omadus; see on vajadus jätkusuutlike ja edukate tarkvaraprojektide loomiseks, olenemata sellest, kus teie või teie meeskond maailmas asute.